/*
* Copyright (C) ${year} The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.threadsample;
import com.example.android.threadsample.PhotoDecodeRunnable.TaskRunnableDecodeMethods;
import java.io.EOFException;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
/**
* This task downloads bytes from a resource addressed by a URL. When the task
* has finished, it calls handleState to report its results.
*
* Objects of this class are instantiated and managed by instances of PhotoTask, which
* implements the methods of {@link TaskRunnableDecodeMethods}. PhotoTask objects call
* {@link #PhotoDownloadRunnable(TaskRunnableDownloadMethods) PhotoDownloadRunnable()} with
* themselves as the argument. In effect, an PhotoTask object and a
* PhotoDownloadRunnable object communicate through the fields of the PhotoTask.
*/
class PhotoDownloadRunnable implements Runnable {
// Sets the size for each read action (bytes)
private static final int READ_SIZE = 1024 * 2;
// Sets a tag for this class
@SuppressWarnings("unused")
private static final String LOG_TAG = "PhotoDownloadRunnable";
// Constants for indicating the state of the download
static final int HTTP_STATE_FAILED = -1;
static final int HTTP_STATE_STARTED = 0;
static final int HTTP_STATE_COMPLETED = 1;
// Defines a field that contains the calling object of type PhotoTask.
final TaskRunnableDownloadMethods mPhotoTask;
/**
*
* An interface that defines methods that PhotoTask implements. An instance of
* PhotoTask passes itself to an PhotoDownloadRunnable instance through the
* PhotoDownloadRunnable constructor, after which the two instances can access each other's
* variables.
*/
interface TaskRunnableDownloadMethods {
/**
* Sets the Thread that this instance is running on
* @param currentThread the current Thread
*/
void setDownloadThread(Thread currentThread);
/**
* Returns the current contents of the download buffer
* @return The byte array downloaded from the URL in the last read
*/
byte[] getByteBuffer();
/**
* Sets the current contents of the download buffer
* @param buffer The bytes that were just read
*/
void setByteBuffer(byte[] buffer);
/**
* Defines the actions for each state of the PhotoTask instance.
* @param state The current state of the task
*/
void handleDownloadState(int state);
/**
* Gets the URL for the image being downloaded
* @return The image URL
*/
URL getImageURL();
}
/**
* This constructor creates an instance of PhotoDownloadRunnable and stores in it a reference
* to the PhotoTask instance that instantiated it.
*
* @param photoTask The PhotoTask, which implements TaskRunnableDecodeMethods
*/
PhotoDownloadRunnable(TaskRunnableDownloadMethods photoTask) {
mPhotoTask = photoTask;
}
/*
* Defines this object's task, which is a set of instructions designed to be run on a Thread.
*/
@SuppressWarnings("resource")
@Override
public void run() {
/*
* Stores the current Thread in the the PhotoTask instance, so that the instance
* can interrupt the Thread.
*/
mPhotoTask.setDownloadThread(Thread.currentThread());
// Moves the current Thread into the background
android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_BACKGROUND);
/*
* Gets the image cache buffer object from the PhotoTask instance. This makes the
* to both PhotoDownloadRunnable and PhotoTask.
*/
byte[] byteBuffer = mPhotoTask.getByteBuffer();
/*
* A try block that downloads a Picasa image from a URL. The URL value is in the field
* PhotoTask.mImageURL
*/
// Tries to download the picture from Picasa
try {
// Before continuing, checks to see that the Thread hasn't been
// interrupted
if (Thread.interrupted()) {
throw new InterruptedException();
}
// If there's no cache buffer for this image
if (null == byteBuffer) {
/*
* Calls the PhotoTask implementation of {@link #handleDownloadState} to
* set the state of the download
*/
mPhotoTask.handleDownloadState(HTTP_STATE_STARTED);
// Defines a handle for the byte download stream
InputStream byteStream = null;
// Downloads the image and catches IO errors
try {
// Opens an HTTP connection to the image's URL
HttpURLConnection httpConn =
(HttpURLConnection) mPhotoTask.getImageURL().openConnection();
// Sets the user agent to report to the server
httpConn.setRequestProperty("User-Agent", Constants.USER_AGENT);
// Before continuing, checks to see that the Thread
// hasn't been interrupted
if (Thread.interrupted()) {
throw new InterruptedException();
}
// Gets the input stream containing the image
byteStream = httpConn.getInputStream();
if (Thread.interrupted()) {
throw new InterruptedException();
}
/*
* Gets the size of the file being downloaded. This
* may or may not be returned.
*/
int contentSize = httpConn.getContentLength();
/*
* If the size of the image isn't available
*/
if (-1 == contentSize) {
// Allocates a temporary buffer
byte[] tempBuffer = new byte[READ_SIZE];
// Records the initial amount of available space
int bufferLeft = tempBuffer.length;
/*
* Defines the initial offset of the next available
* byte in the buffer, and the initial result of
* reading the binary
*/
int bufferOffset = 0;
int readResult = 0;
/*
* The "outer" loop continues until all the bytes
* have been downloaded. The inner loop continues
* until the temporary buffer is full, and then
* allocates more buffer space.
*/
outer: do {
while (bufferLeft > 0) {
/*
* Reads from the URL location into
* the temporary buffer, starting at the
* next available free byte and reading as
* many bytes as are available in the
* buffer.
*/
readResult = byteStream.read(tempBuffer, bufferOffset,
bufferLeft);
/*
* InputStream.read() returns zero when the
* file has been completely read.
*/
if (readResult < 0) {
// The read is finished, so this breaks
// the to "outer" loop
break outer;
}
/*
* The read isn't finished. This sets the
* next available open position in the
* buffer (the buffer index is 0-based).
*/
bufferOffset += readResult;
// Subtracts the number of bytes read from
// the amount of buffer left
bufferLeft -= readResult;
if (Thread.interrupted()) {
throw new InterruptedException();
}
}
/*
* The temporary buffer is full, so the
* following code creates a new buffer that can
* contain the existing contents plus the next
* read cycle.
*/
// Resets the amount of buffer left to be the
// max buffer size
bufferLeft = READ_SIZE;
/*
* Sets a new size that can contain the existing
* buffer's contents plus space for the next
* read cycle.
*/
int newSize = tempBuffer.length + READ_SIZE;
/*
* Creates a new temporary buffer, moves the
* contents of the old temporary buffer into it,
* and then points the temporary buffer variable
* to the new buffer.
*/
byte[] expandedBuffer = new byte[newSize];
System.arraycopy(tempBuffer, 0, expandedBuffer, 0,
tempBuffer.length);
tempBuffer = expandedBuffer;
} while (true);
/*
* When the entire image has been read, this creates
* a permanent byte buffer with the same size as
* the number of used bytes in the temporary buffer
* (equal to the next open byte, because tempBuffer
* is 0=based).
*/
byteBuffer = new byte[bufferOffset];
// Copies the temporary buffer to the image buffer
System.arraycopy(tempBuffer, 0, byteBuffer, 0, bufferOffset);
/*
* The download size is available, so this creates a
* permanent buffer of that length.
*/
} else {
byteBuffer = new byte[contentSize];
// How much of the buffer still remains empty
int remainingLength = contentSize;
// The next open space in the buffer
int bufferOffset = 0;
/*
* Reads into the buffer until the number of bytes
* equal to the length of the buffer (the size of
* the image) have been read.
*/
while (remainingLength > 0) {
int readResult = byteStream.read(
byteBuffer,
bufferOffset,
remainingLength);
/*
* EOF should not occur, because the loop should
* read the exact # of bytes in the image
*/
if (readResult < 0) {
// Throws an EOF Exception
throw new EOFException();
}
// Moves the buffer offset to the next open byte
bufferOffset += readResult;
// Subtracts the # of bytes read from the
// remaining length
remainingLength -= readResult;
if (Thread.interrupted()) {
throw new InterruptedException();
}
}
}
if (Thread.interrupted()) {
throw new InterruptedException();
}
// If an IO error occurs, returns immediately
} catch (IOException e) {
e.printStackTrace();
return;
/*
* If the input stream is still open, close it
*/
} finally {
if (null != byteStream) {
try {
byteStream.close();
} catch (Exception e) {
}
}
}
}
/*
* Stores the downloaded bytes in the byte buffer in the PhotoTask instance.
*/
mPhotoTask.setByteBuffer(byteBuffer);
/*
* Sets the status message in the PhotoTask instance. This sets the
* ImageView background to indicate that the image is being
* decoded.
*/
mPhotoTask.handleDownloadState(HTTP_STATE_COMPLETED);
// Catches exceptions thrown in response to a queued interrupt
} catch (InterruptedException e1) {
// Does nothing
// In all cases, handle the results
} finally {
// If the byteBuffer is null, reports that the download failed.
if (null == byteBuffer) {
mPhotoTask.handleDownloadState(HTTP_STATE_FAILED);
}
/*
* The implementation of setHTTPDownloadThread() in PhotoTask calls
* PhotoTask.setCurrentThread(), which then locks on the static ThreadPool
* object and returns the current thread. Locking keeps all references to Thread
* objects the same until the reference to the current Thread is deleted.
*/
// Sets the reference to the current Thread to null, releasing its storage
mPhotoTask.setDownloadThread(null);
// Clears the Thread's interrupt flag
Thread.interrupted();
}
}
}